package com.kingsoft.dc.khaos.dsl.spark.udf.model

import java.sql.Timestamp

/**
  * udf名称定义
  *
  * @author gaosong3@kingsoft.com
  * @date 2019/3/14
  */
object UdfDefine {
  val AES_KEY: String = "1234567890123456" //AES密钥,需要16位
  val AES_KEY2: String = "21202F2938212B3E22272626252E434D" //AES密钥,需要31位,备用

  /**
    * 空值处理udf
    */
  def null2DateUDF(input: Any): Timestamp = {
    ColumnHandler.null2Date(input)
  }
  def null2FloatUDF(input: Any): java.lang.Float = {
    ColumnHandler.null2Float(input)
  }
  def null2IntUDF(input: Any): Integer = {
    ColumnHandler.null2Int(input)
  }

  /**
    * MD5加密
    * @param inputCol 输入字符串
    * @return java.lang.String 加密后的字符串
    */
  def md5EncryptUDF(inputCol: String): String = {
    ColumnHandler.MD5(inputCol)
  }

  /**
    * Base64加密
    * @param inputCol 输入参数可以为中文字符
    * @return java.lang.String 返回Base64加密后的结果
    */
  def base64EncryptUDF(inputCol: String): String = {
    ColumnHandler.base64Encrypt(inputCol)
  }

  /**
    * Base64解密
    * @param inputCol 输入参数可以为中文字符
    * @return java.lang.String 返回Base64解密后的结果
    */
  def base64DecryptUDF(inputCol: String): String = {
    ColumnHandler.base64Decrypt(inputCol)
  }

  /**
    * AES加密
    * @param inputCol 输入参数可以为中文字符
    * @return java.lang.String 返回加密后的加密字段
    */
  def aesEncryptUDF(inputCol: String): String = {
    ColumnHandler.aesEncrypt(inputCol)
  }

  /**
    * AES解密
    * @param inputCol 输入参数可以为中文字符
    * @return java.lang.String 返回解密后的原始字段
    */
  def aesDecryptUDF(inputCol: String): String = {
    ColumnHandler.aesDecrypt(inputCol)
  }

  /**
    * 全脱敏
    * @param inputCol 输入参数可以为中文字符
    * @return java.lang.String 返回数据全脱敏后的结果，不可逆。传入数据，返回结果为“****”
    */
  def dataHideUDF(inputCol: String): String = {
    ColumnHandler.dataHide(inputCol)
  }

  /**
    * 部分脱敏
    * @param inputCol 输入参数可以为中文字符
    * @return java.lang.String 返回数据部分脱敏后的结果，不可逆。传入数据，返回结果形如“138****4567”
    */
  def halfDataHideUDF(inputCol: String): String = {
    ColumnHandler.halfDataHide(inputCol)
  }

  /**
    * 判断是否为空
    * @param inputCol 输入参数
    * @return boolean  如果input为null、""、" "三种情况就返回true，否则返回false
    */
  def isNullUDF(inputCol: Any): Boolean = {
    ColumnHandler.isNull(inputCol)
  }

  /**
    * 判断是否不为空
    * @param inputCol 输入参数
    * @return boolean 如果a为非null、非""、非" "三种情况就返回true，否则返回false
    */
  def isNotNullUDF(inputCol: Any): Boolean = {
    ColumnHandler.isNotNull(inputCol)
  }

  /**
    * 返回str中首个ASCII字符串的整数值
    * @param inputCol 输入str
    * @return int str中首个ASCII字符串的整数值
    */
  def asciiUDF(inputCol: String): Int = {
    ColumnHandler.ascii(inputCol)
  }

  /**
    * 连接字符串
    * @param inputCol1 需要连接的第一个字符串
    * @param inputCol2 需要连接的第二个字符串
    * @return java.lang.String 拼接后的字符串
    */
  def concatUDF(inputCol1: String,inputCol2:String): String = {
    ColumnHandler.concat(inputCol1,inputCol2)
  }

  /**
    * 指定分隔符连接字符串
    * @param inputCol1 需要连接的第一个字符串
    * @param inputCol2 需要连接的第二个字符串
    * @param separator 指定分隔符
    * @return java.lang.String 拼接后的字符串
    */
  def concatSeparatorUDF(inputCol1: String,inputCol2:String,separator:String): String = {
    ColumnHandler.concat(inputCol1,inputCol2,separator)
  }

  /**
    * 返回字符串长度
    * @param inputCol 输入的字符串
    * @return int 字符串长度
    */
  def lengthUDF(inputCol: String): Int = {
    ColumnHandler.length(inputCol)
  }

  /**
    * 去掉字符串中的所有空格
    * @param inputCol 输入字符串
    * @return java.lang.String
    */
  def trimAllUDF(inputCol: String): String = {
    ColumnHandler.trimAll(inputCol)
  }

  /**
    * 去掉字符串前后空格
    * @param inputCol 输入字符串
    * @return java.lang.String
    */
  def trimUDF(inputCol: String): String = {
    ColumnHandler.trim(inputCol)
  }

  /**
    * 翻转字符串
    * @param inputCol 输入字符串
    * @return java.lang.String
    */
  def reverseUDF(inputCol: String): String = {
    ColumnHandler.reverse(inputCol)
  }

  /**
    * 返回指定个数空格生成的字符串
    * @param input 空格个数
    * @return java.lang.String
    */
  def spaceUDF(input: Int): String = {
    ColumnHandler.space(input)
  }

  /**
    * 返回字符串从第一个字符开始到第n个字符
    * @param inputCol 输入字符串
    * @param length 需要截取的长度
    * @return java.lang.String
    */
  def subStrUDF(inputCol: String,length:Int): String = {
    ColumnHandler.subStr(inputCol,length)
  }

  /**
    * 返回第1个指定位置字符之后的所有字符
    * @param inputCol 输入字符串
    * @param tag 指定字符
    * @return java.lang.String 返回字符串“inputCol”中“tag”之后的所有字符，不包含指定字符“tag”
    */
  def subStrLaterUDF(inputCol: String,tag:String): String = {
    ColumnHandler.subStrLater(inputCol,tag)
  }

  /**
    * 返回第1个指定位置字符之前的所有字符
    * @param inputCol 输入字符串
    * @param tag 指定字符
    * @return java.lang.String 返回字符串“inputCol”中“tag”之前的所有字符，不包含指定字符“tag”
    */
  def subStrBeforeUDF(inputCol: String,tag:String): String = {
    ColumnHandler.subStrBefore(inputCol,tag)
  }

  /**
    * 返回指两个字符中间的所有字符
    * @param inputCol 输入字符串
    * @param bef 指定的第一个字符
    * @param end 指定的第二个字符
    * @return java.lang.String 返回字符“bef”到“end”之间的所有字符，不含“bef”和“end”, 如果包含多个,则取第一个bef和最后一个end
    */
  def subStrMidUDF(inputCol: String,bef:String,end:String): String = {
    ColumnHandler.subStrMid(inputCol,bef,end)
  }



  /**
    * 返回指两个字符中间的所有字符
    * @param inputCol 输入字符串
    * @param bef 指定的第一个字符
    * @param end 指定的第二个字符
    * @return java.lang.String 返回字符“bef”到“end”之间的所有字符，不含“bef”和“end”, 如果包含多个,则取第一个bef和最后一个end
    */
  def subStrMid2UDF(inputCol: String,bef:Int,end:Int): String = {
    ColumnHandler.subStrMid2(inputCol,bef,end)
  }



  /**
    * 将输入字符串转换为大写字符
    * @param inputCol 输入字符串
    * @return java.lang.String 转换大写后的字符串
    */
  def toUpperUDF(inputCol: String): String = {
    ColumnHandler.toUpper(inputCol)
  }

  /**
    * 将输入字符串转换为小写字符
    * @param inputCol 输入字符串
    * @return java.lang.String 转换小写后的字符串
    */
  def toLowerUDF(inputCol: String): String = {
    ColumnHandler.toLower(inputCol)
  }

  /**
    * 日期格式化函数
    * @param timestamp 时间秒值 单位:秒
    * @param format 转化的格式  eg: yyyy-MM-dd hh:mm:ss
    * @return java.lang.String 转化后的时间
    */
  def fromUnixTimeUDF(timestamp: Long,format:String): String = {
    ColumnHandler.fromUnixTime(timestamp,format)
  }

  /**
    * 获取当前UTC时间
    * @return java.lang.String 返回时间秒值
    */
  def currentTimestampUDF(): Long = {
    ColumnHandler.currentTimestamp()
  }

  /**
    * 获取当前UTC时间
    * @return java.lang.String 返回时间毫秒值
    */
  def currentTimestampMsUDF(): Long = {
    ColumnHandler.currentTimestampMs()
  }

  /**
    * 固定格式时间转UTC时间 格式: yyyy-MM-dd HH:mm:ss
    * @param date 传入的时间
    * @return long UTC时间
    */
  def unixTimestampUDF(date: String): Long = {
    ColumnHandler.unixTimestamp(date)
  }

  /**
    * 固定格式时间转UTC时间 格式: yyyy-MM-dd HH:mm:ss
    * @param date 传入的时间
    * @return long UTC时间 单位:毫秒
    */
  def unixTimestampMsUDF(date: String): Long = {
    ColumnHandler.unixTimestampMs(date)
  }

  /**
    * 指定格式时间转UTC时间
    * @param date 传入的时间
    * @param pattern 指定格式
    * @return long UTC时间
    */
  def unixTimestampPatternUDF(date: String,pattern:String): Long = {
    ColumnHandler.unixTimestamp(date,pattern)
  }

  /**
    * 指定格式时间转UTC时间
    * @param date 传入的时间
    * @param pattern 指定格式
    * @return long UTC时间 单位:毫秒
    */
  def unixTimestampMsPatternUDF(date: String,pattern:String): Long = {
    ColumnHandler.unixTimestampMs(date,pattern)
  }

  /**
   * 指定格式时间转UTC时间(兼容SSS)
   * @param date 传入的时间
   * @param pattern 指定格式
   * @return long UTC时间 单位:毫秒
   */
  def unixTimestampMsPlusPatternUDF(date: String,pattern:String): Long = {
      ColumnHandler.unixTimestampMsPlus(date,pattern)
  }

  /**
    * 返回日期字符串的日期部分
    * @param timestamp 指定日期
    * @return java.lang.String 日期部分 eg : to_date("1970-01-01 00:00:00") = "1970-01-01"
    */
  def toDateUDF(timestamp: String): String = {
    ColumnHandler.toDate(timestamp)
  }

  /**
    * 返回日期字符串的日期部分
    * @param timestamp 指定日期
    * @return java.lang.String 日期部分 eg : to_date("1970-01-01 00:00:00") = "1970-01-01"
    */
  def toDate2UDF(timestamp: String): String = {
    ColumnHandler.toDate2(timestamp)
  }


  /**
    * 返回时间字符串的年份
    * @param date 时间字符串
    * @return int eg : year("1970-01-01 00:00:00") = 1970, year("1970-01-01") = 1970
    */
  def yearUDF(date: String): Int = {
    ColumnHandler.year(date)
  }

  /**
    * 返回时间字符串的季度
    * @param date 时间字符串
    * @return int eg : quarter('2015-04-08') = 2
    */
  def quarterUDF(date: String): Int = {
    ColumnHandler.quarter(date)
  }

  /**
    * 返回时间字符串的月份
    * @param date 时间字符串
    * @return int eg: month("1970-11-01 00:00:00") = 11, month("1970-11-01") = 11
    */
  def monthUDF(date: String): Int = {
    ColumnHandler.month(date)
  }

  /**
    * Int型转Double型
    *
    * @param num 输入Int类型数值
    * @return 输出Double类型数值
    */
  def int2DoubleUDF(num: Int): Double = {
    ColumnHandler.int2Double(num)
  }

  /**
    * Int型转Float型
    *
    * @param num 输入Int类型数值
    * @return 输出Float类型数值
    */
  def int2FloatUDF(num: Int): Float = {
    ColumnHandler.int2Float(num)
  }

  /**
    * Int型转Long型
    *
    * @param num 输入Int类型数值
    * @return 输出Long类型数值
    */
  def int2LongUDF(num: Int): Long = {
    ColumnHandler.int2Long(num)
  }

  /**
    * Long型转Double型
    *
    * @param num 输入Long类型数值
    * @return 输出Double类型数值
    */
  def long2DoubleUDF(num: Long): Double = {
    ColumnHandler.long2Double(num)
  }

  /**
    * Long型转Int型
    *
    * @param num 输入Long类型数值
    * @return 输出Int类型数值
    */
  def long2IntUDF(num: Long): Int = {
    ColumnHandler.long2Int(num)
  }

  /**
    * float型转int型
    *
    * @param num 输入float类型数值
    * @return 输出Int类型数值
    */
  def float2IntUDF(num: Float): Int = {
    ColumnHandler.float2Int(num)
  }

  /**
    * float型转Long型
    *
    * @param num 输入float类型数值
    * @return 输出Long类型数值
    */
  def float2LongUDF(num: Float): Long = {
    ColumnHandler.float2Long(num)
  }

  /**
    * float型转double型
    *
    * @param num 输入float类型数值
    * @return 输出double类型数值
    */
  def float2DoubleUDF(num: Float): Double = {
    ColumnHandler.float2Double(num)
  }

  /**
    * double型转Long型
    *
    * @param num 输入double类型数值
    * @return 输出Long类型数值
    */
  def double2LongUDF(num: Double): Long = {
    ColumnHandler.double2Long(num)
  }

  /**
    * double型转float型
    *
    * @param num 输入double类型数值
    * @return 输出float类型数值
    */
  def double2FloatUDF(num: Double): Float = {
    ColumnHandler.double2Float(num)
  }

  /**
    * 任意类型转为字符型
    *
    * @param input 输入字符串类型
    * @return 输出字符串类型
    */
  def any2StrUDF(input: Any): String = {
    ColumnHandler.any2Str(input)
  }

  /**
    * 字符串转换为Boolean型
    *
    * @param input 输入字符串
    * @return 输出Boolean类型结果
    */
  def str2BooleanUDF(input: String): Boolean = {
    ColumnHandler.str2Boolean(input)
  }

  /**
    * 字符串转换为Char型
    *
    * @param input 输入字符串
    * @return 输出Char类型结果
    */
  def str2CharUDF(input: String): String = {
    ColumnHandler.str2Char(input)
  }

  /**
    * 字符串转换为Short型
    *
    * @param input 输入字符串
    * @return 输出Short类型结果
    */
  def str2ShortUDF(input: String): Short = {
    ColumnHandler.str2Short(input)
  }

  /**
    * 字符串转换为Double型
    *
    * @param input 输入字符串
    * @return 输出Double类型结果
    */
  def str2DoubleUDF(input: String): Double = {
    ColumnHandler.str2Double(input)
  }

  /**
    * 字符串转换为Long型
    *
    * @param input 输入字符串
    * @return 输出Long类型结果
    */
  def str2LongUDF(input: String): Long = {
    ColumnHandler.str2Long(input)
  }

  /**
    * 字符串转换为Float型
    *
    * @param input 输入字符串
    * @return 输出Float类型结果
    */
  def str2FloatUDF(input: String): Float = {
    ColumnHandler.str2Float(input)
  }

  /**
    * 字符串转换为int型
    *
    * @param input 输入字符串
    * @return 输出Int类型结果
    */
  def str2IntUDF(input: String): Int = {
    ColumnHandler.str2Int(input)
  }

  /**
    * 求最大值UDF
    * 若输入参数1为String类型,则输入参数2为Char类型或者String类型才能比较
    *
    * @param input1 输入任意类型参数1
    * @param input2 输入任意类型参数2
    * @return 返回较大值
    */
  def greatestUDF(input1: Any, input2: Any): Any = {
    ColumnHandler.greatest(input1, input2)
  }

  /**
    * 求最小值UDF
    * 若输入参数1为String类型,则输入参数2为Char类型或者String类型才能比较
    *
    * @param input1 输入任意类型参数1
    * @param input2 输入任意类型参数2
    * @return 返回较小值
    */
  def leastUDF(input1: Any, input2: Any): Any = {
    ColumnHandler.least(input1, input2)
  }

  /**
    * 相反数
    *
    * @param num Double类型数值
    * @return Double类型结果
    */
  def negativeDoubleUDF(num: Double): Double = {
    ColumnHandler.negative(num)
  }

  /**
    * 相反数
    *
    * @param num Int类型数值
    * @return Int类型结果
    */
  def negativeIntUDF(num: Int): Int = {
    ColumnHandler.negative(num)
  }

  /**
    * 取模运算
    *
    * @param num1 Double数值1
    * @param num2 Double数值2
    * @return 结果
    */
  def pmodIntUDF(num1: Double, num2: Double): Double = {

    ColumnHandler.pmod(num1, num2)
  }

  /**
    * 取模运算
    *
    * @param num1 Int数值1
    * @param num2 Int数值2
    * @return 结果
    */
  def pmodDoubleUDF(num1: Int, num2: Int): Int = {
    ColumnHandler.pmod(num1, num2)
  }

  /**
    * 绝对值
    *
    * @param num 数值
    * @return 返回结果
    */
  def absUDF(num: Double): Double = {
    ColumnHandler.abs(num)
  }

  /**
    * 银行家四舍五入(保留指定位数)
    *
    * @param num 数值
    * @param  bl  指定位数
    * @return 返回结果
    */
  def broundBitsUDF(num: Double, bl: Int): Double = {
    ColumnHandler.bround(num, bl)
  }

  /**
    * 银行家四舍五入
    *
    * @param num 数值
    * @return 返回结果
    */
  def broundUDF(num: Double): Double = {
    ColumnHandler.bround(num)
  }

  /**
    * 四舍五入
    *
    * @param num
    * @return
    */
  def roundUDF(num: Double): Double = {
    ColumnHandler.round(num)
  }

  /**
    * 四舍五入（保留指定小数位数）
    *
    * @param num 输入小数
    * @param bl  保留指定位
    * @return 结果
    */
  def roundBitsUDF(num: Double, bl: Int): Double = {
    ColumnHandler.round(num, bl)
  }

  /**
    * 两数相除UDF
    *
    * @param num1
    * @param num2
    * @return 商
    */
  def divUDF(num1: Double, num2: Double): Double = {
    ColumnHandler.div(num1, num2)
  }

  /**
    * 两数相乘UDF
    *
    * @param num1
    * @param num2
    * @return 积
    */
  def mulUDF(num1: Double, num2: Double): Double = {
    ColumnHandler.mul(num1, num2)
  }


  /**
    * 两数相减UDF
    *
    * @param num1 数值1
    * @param num2 数值2
    * @return 差
    */
  def subUDF(num1: Double, num2: Double): Double = {
    ColumnHandler.sub(num1, num2)
  }

  /**
    * 两数相加UDF
    *
    * @param num1 数值1
    * @param num2 数值2
    * @return 和
    */
  def addUDF(num1: Double, num2: Double): Double = {
    ColumnHandler.add(num1, num2)
  }

  /**
    * utf-8编码字符串转换成Unicode编码字符串
    *
    * @param input utf-8编码格式,用分割,例如:28-72-83-27-101-67
    * @return Unicode编码
    */
  def UTF8ToUnicodeUDF(input: String): String = {
    ColumnHandler.UTF8ToUnicode(input)
  }

  /**
    * Unicode编码字符串转换成utf-8编码字符串
    *
    * @param input Unicode编码格式,用分割,例如:28-72-83-27-101-67
    * @return UTF-8编码
    */
  def UnicodeToUTF8UDF(input: String): String = {
    ColumnHandler.UnicodeToUTF8(input)
  }

  /**
    * ISO-8859-1编码字符串转换成utf-8编码字符串
    *
    * @param input ISO-8859-1编码格式,用分割,例如:28-72-83-27-101-67
    * @return GBK编码
    */
  def ISOToGBKUDF(input: String): String = {
    ColumnHandler.ISOToGBK(input)
  }

  /**
    * GBK编码字符串转换成utf-8编码字符串
    *
    * @param input GBK编码格式,用分割,例如:28-72-83-27-101-67
    * @return UTF-8编码
    */
  def GBKToUTF8UDF(input: String): String = {
    ColumnHandler.GBKToUTF8(input)
  }

  /**
    * 对utf-8编码字符串转换成gbk编码字符串
    *
    * @param input utf-8编码格式,用分割,例如:28-72-83-27-101-67
    * @return
    */
  def UTF8ToGBKUDF(input: String): String = {
    ColumnHandler.UTF8ToGBK(input)
  }

  /**
    * println code "21202F2938212B3E22272626252E434D"
    *
    * @param input   输入的字符串
    * @param charset 指定的编码字符集
    * @return 编码后的字符串
    */
  def uselessUDF(nothing: String) = {
    println(AES_KEY2)
  }


  /**
    * 对字符串按照指定字符集进行编码
    *
    * @param input   输入的字符串
    * @param charset 指定的编码字符集
    * @return 编码后的字符串
    */
  def recodeUDF(input: String, charset: String): String = {
    ColumnHandler.recode(input, charset)
  }


}
